/**
 * 在使用非空、数字、长度等内部验证方法时，如果用户没有给定提示语言
 * 则使用默认的提示
 * 
 * 在ie6下 不支持jquery的trim()方法
 * 使用说明：
 * 引入plugins/whb.livali.language-zh_CN.js
 *     plugins/whb.livali.js
 * 1.初始化方法$.livali.init(param,[formId]);
 *   1）formId为可选参数，指页面表单的id
 *   2)param格式如下所示：
 * param = [ {
	objid : "name", 
	triggerid : "buttonOk",
	eventname : "blur",
	func : [{
		body:$.livali.notNull
	},{
		body:validateName,
		msg:database_input_rdatabaseNameExist
	}],
    tposition: "right" //提示位置:top left right bottom
  
},
{
	objid : "code",
	eventname : "blur",
	func : [{
		
		body:$.livali.notNull
	},{
	
		body:$.livali.lengthLimit,
		fparameter:[20]
	},{
		
		body:validateCode,
		msg:database_input_rdatabaseCodeExist,
		fparameter:["ss",t]
	}],
    tposition: "left",
    aftervalidate:{
       name:"t",
       body:t,
       fparameter:["te"]
    },
	valinotvisible:false,
    
}]
    参数说明 objid:String 要验证的对象id
             triggerid:String 要绑定事件的对象id，当事件触发对象和验证对象不同时，使用该参数
                              如，点击某button时，对某input项进行验证
             eventname:String 要绑定的事件名 blur click等 
             func:Array 要绑定的函数
          
             func.body:function 函数
             func.msg:String 与该函数对应的错误提示语，对于内置验证函数可以不提供该参数，
                             对应使用系统默认提示语
             func.fparameter:Array 函数的参数数组，**注意** 数组元素个数及排列顺序必需与函数对应
                             参数数组中的元素可为js方法，方法的返回值会做为参数传递给验证函数
                             如：fparameter:["yes",getName] 其中getName为一个取值方法
             tposition:String 提示框显示位置 可接受的值为 top left right bottom
             aftervalidate.body:function  对于某对象验证通过后要执行的函数
             aftervalidate.fparameter:Array  aftervalidater的参数数组
             valinotvisible:boolean 设置当某对象不显示时，是否进行验证 true 验证 false不验证 默认为验证
       2）如需要在脚本中触发所有验证，使用$.livali.validateAll() @returns {Boolean}
           
           如 var flag = $.livali.validateAll();
              if(flag){
                 ......
              }
       3)如在某条件下需要关闭某对象的某验证，使用$.livali.addIgnore(objId,functionName)
        objId:String 对象id
        functionName:String 函数名称
       4)取消对某验证的关闭，使用$.livali.deleteIgnore(objId,functionName);
         objId:String 对象id
        functionName:String 函数名称
       5)目前的内置验证函数： *注* event参数不用显式设置 即 func.fparameter:Array 中不能包括event参数
 **
	 * 非空验证
	 * 
	 * @param event
	 * @returns {Boolean}
	 *
	notNull : function(event)
	
		/**
	 * 长度验证
	 * 
	 * @param event
	 *
	lengthLimit : function(limitValue, event)
	
		/**
	 * 数字验证(正整数)
	 * 
	 * @param event
	 *
	isPInteger : function(event) 
	
		/**
	 * 数字验证(非负整数)
	 * 
	 * @param event
	 * @returns {Boolean}
	 *
	notNInteger : function(event) 
	
	/**
	 * IP验证
	 * 
	 * @param event
	 * @returns {Boolean}
	 *
	isIpv4 : function(event)
	
		/**
	 * 日期时间格式判定
	 * 
	 * @param event
	 * @returns {Boolean}
	 *
	isDateTime : function(event)
	
		/**
	 * 日期格式判定
	 * 
	 * @param event
	 * @returns {Boolean}
	 *
	isDate : function(event)
	
		/**
	 * 判断是否有特殊字符 &%()<>\'",
	 * 
	 *
	noSpecialCharacter : function(event)
	
		/**
	 * 多选列表非空判定
	 *
	multiSelNotNull : function(event)
	
	/**
	 * checkboxlist至少勾选了指定数目校验
	 * 
	 * @param chkName
	 *            checkboxlist(复选框组)名称
	 * @param leastChkNum
	 *            至少勾选数目
	 *
	leastChkNum : function(chkName, leastChkNum, event)
	
	/**
	 * 数字验证(范围整数)
	 * 
	 * @param min
	 *            值为null表示支持无穷小
	 * @param max
	 *            值为null表示支持无穷大
	 * 该方法无法随意配置提示信息
	 *
	rangeInteger : function(min, max, event)
	
	/**
	 * 最小时间验证
	 * @param minDateTime
	 * @param event
	 * @returns {Boolean}
	 *
	futureDateTime : function(minDateTime,event) 
	
		/**
	 * 最小日期验证
	 * @param minDate
	 * @param event
	 * @returns {Boolean}
	 *
	futureDate : function(minDate,event)
	
		/**
	 * 最大时间验证
	 * @param minDateTime
	 * @param event
	 * @returns {Boolean}
	 *
	pastDateTime : function(maxDateTime,event)
	
		/**
	 * 最大日期验证
	 * @param minDate
	 * @param event
	 * @returns {Boolean}
	 *
	pastDate : function(maxDate,event)
 */

 


/**
显示提示信息
*/
messageShow = function(jqueryObj, msg, tipPosition){
	if(!jqueryObj.data('tipShow')){
		var tp=1,tipIndex;
	switch(tipPosition){
		case 'top':tp=1;break;
		case 'right':tp=2;break;
		case 'bottom':tp=3;break;
		case 'left':tp=4;break;
		default:tp=1;
	}
	tipIndex = layer.tips("<span style='color:red;'>"+msg+"</span>", jqueryObj, {
                tips: [tp, '#ffff33'],
				closeBtn:0,
				tipsMore:true,
			    time: 0
            });
	jqueryObj.data('tipIndex',tipIndex);
	jqueryObj.data('tipShow',true);
	
	//添加弹出层的关闭事件
	
	$('#layui-layer'+tipIndex).click(function(){
		layer.close(tipIndex);
		jqueryObj.data('tipShow',false);
	});
	}
	
	
}


/**
 * 关闭提示信息
 * 
 * @param jqueryObj
 */
messageHide = function(jqueryObj) {
		
	if(jqueryObj.data('tipShow')){
		layer.close(jqueryObj.data('tipIndex'));
	}
};

/* 获取字符串实际长度，按中文占3个字符，英文占1个字符计算 */
function getLength(s) {
	var char_length = 0;
	for ( var i = 0; i < s.length; i++) {
		var son_char = s.charAt(i);
		encodeURI(son_char).length > 2 ? char_length += 3 : char_length += 1;
	}
	return char_length;
}
// trim
trim = function(str) {
	str = str.replace(/(^\s*)|(\s*$)/g, "");
    while ( str.indexOf("  ", 0) != -1 ) {
    	str = str.replace("  ", " ");
    }
    return str;
};
/**
 * 判断对象是否存在
 * 
 * @param id
 */
isExist = function(id) {
	if ($("#" + id).length > 0) {
		return true;
	} else {
		return false;
	}
};

$.livali = {
	/**
	 * 常用正则表达式
	 */
	pIntegerReg : /^[1-9]\d*$/, // 正整数	
	notNIntegerReg : /^[1-9]\d*$|^0$/, // 非负整数
	integerReg : /^-?\d+$/, // 整数	
	floatReg : /^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$/, // 浮点数
	// IPV4
	isIpv4Reg : /^([1-9]|[1-9]\d|1\d{2}|2[0-1]\d|22[0-3])(\.(\d|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])){3}$/, 
	// 日期时间
	isDateTimeReg : /^((((1[6-9]|[2-9]\d)\d{2})-(0?[13578]|1[02])-(0?[1-9]|[12]\d|3[01]))|(((1[6-9]|[2-9]\d)\d{2})-(0?[13456789]|1[012])-(0?[1-9]|[12]\d|30))|(((1[6-9]|[2-9]\d)\d{2})-0?2-(0?[1-9]|1\d|2[0-8]))|(((1[6-9]|[2-9]\d)(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00))-0?2-29-)) (20|21|22|23|[0-1]?\d):[0-5]?\d:[0-5]?\d$/, 
	// 日期
	isDateReg : /^((((1[6-9]|[2-9]\d)\d{2})-(0?[13578]|1[02])-(0?[1-9]|[12]\d|3[01]))|(((1[6-9]|[2-9]\d)\d{2})-(0?[13456789]|1[012])-(0?[1-9]|[12]\d|30))|(((1[6-9]|[2-9]\d)\d{2})-0?2-(0?[1-9]|1\d|2[0-8]))|(((1[6-9]|[2-9]\d)(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00))-0?2-29-))$/, 
	specialCharacterReg : /[\&\%\(\\\)\"\'\,\<\>]/g, // 判断是否有特殊字符 &%()\',<>"
	numLetterUnderLineOnlyReg : /^[a-zA-Z0-9_]{1,}$/, // 只能输入字母数字下划线
	
	/**
	 * 存放不绑定任何事件的验证函数 只在validateAll() 和 submit()时进行验证 (2013-03-13 还不成熟)
	 */
	validateWithoutEvent : [],
	/**
	 * 存放用户配置信息，用于非submit事件时的验证触发,validateAll()
	 */
	param : [],
	/**
	 * ignoreValidates用于存放忽略的验证{obj,funcName}
	 */
	ignoreValidates : [],
	ignoreObjValidates : new Array(),
	resultflag : true,
	// 验证时是否显示图片，IE下无效
	//imageShow : true,
	init : function(parameters, formId) {
	    $.livali.param = parameters;
		// 为要验证的对象绑定事件，目前还没有考虑对象类型
		for ( var i = 0; i < parameters.length; i++) {
			// 先判断对象是否存在
			if (isExist(parameters[i].objid)) {
				// 验证的对象
				var object = $("#" + parameters[i].objid);
				// 图片的自定义位置
				var imgp = [];
				if (parameters[i].imageposition != ""
						&& typeof parameters[i].imageposition != "undefined") {
					imgp = parameters[i].imageposition;
				}
				//imageInit(object, imgp);
				var triObj = null;
				// 确定要绑定事件的对象
				if (typeof parameters[i].triggerid != "undefined") {
					if (isExist(parameters[i].triggerid)) {
						triObj = $("#" + parameters[i].triggerid);
					} else {
						//alert("id为" + parameters[i].triggerid + "的对象不存在");
						continue;
					}

				} else {
					triObj = $("#" + parameters[i].objid);
				}
				// 提示框位置
				var tp = "top";

				if (parameters[i].tposition != ""
						&& typeof parameters[i].tposition != "undefined") {
					tp = parameters[i].tposition;
				}
				// 提示框精确定位
				var dp = [];
				if (parameters[i].detailposition != ""
						&& typeof parameters[i].detailposition != "undefined") {
					dp = parameters[i].detailposition;
				}
				// 图片全局显示设置为true,绑定显示图片事件
				/*
				if ($.livali.imageShow) {
					// 再看是否单独设置了noimage属性
					if (typeof parameters[i].noimage != "undefined") {
						if (!parameters[i].noimage)
							$(triObj).bind(parameters[i].eventname, object,
									$.livali.openImg);
					} else {
						$(triObj).bind(parameters[i].eventname, object,
								$.livali.openImg);
					}

				}*/

				for ( var j = 0; j < parameters[i].func.length; j++) {
					var mess = "";
					var valiNotVisible = true;
					if (typeof parameters[i].func[j].msg != "undefined") {
						mess = parameters[i].func[j].msg;
					}
					if (typeof parameters[i].valinotvisible != "undefined") {
						valiNotVisible = parameters[i].valinotvisible;
					}
					var data = {
						id : parameters[i].objid,
						obj : object,
						funcname : parameters[i].func[j].body.name,
						funcbody : parameters[i].func[j].body,
						msg : mess,
						tposition : tp,
						detailposition : dp,
						imageposition : imgp,
						valinotvisible : valiNotVisible
					};

					if (typeof parameters[i].func[j].fparameter != "undefined"
							&& parameters[i].func[j].fparameter != null) {
						data.fparameter = parameters[i].func[j].fparameter;
					}
					if (typeof parameters[i].eventname != "undefined") {
						$(triObj).bind(parameters[i].eventname, data,
								$.livali.validateHandler);
					} else {
						// 如果没有设置事件，则将该函数放入validateWithoutEvent
						// 目前该方式不不成熟2013-03-13
						$.livali.validateWithoutEvent.push(data);
					}

				}
				if (typeof parameters[i].aftervalidate != "undefined") {
					var param = null;
					if(typeof parameters[i].aftervalidate.fparameter != "undefiend" )
						param = parameters[i].aftervalidate.fparameter;
					var data = {
						id : parameters[i].objid,
						funcname : parameters[i].aftervalidate.body.name,
						obj : object,
						aftervalidate : parameters[i].aftervalidate.body,
						fparameter:param
					};
					$(triObj).bind(parameters[i].eventname, data,
							$.livali.afterValidteHandler);
				}
				// 每个验证对象，同一事件绑定的最后一个函数，
				// 当执行到该函数时，说明前面的所有验证都已经结束，不论是否通过，都应该关闭等待图片
				//if ($.livali.imageShow) {
				//	$(triObj).bind(parameters[i].eventname, object,
				//			$.livali.closeImg);
				//}
			} else {// 对象不存在
			//	alert("id为" + parameters[i].objid + "的对象不存在");
			}

		}

		// 表单提交前做全部验证
		if (formId != null && formId != "") {
			$("#" + formId)
					.submit(
							function() {
								// 先将标记设置为 true,以防止之前单个对象验证时已经设置为false
								$.livali.resultflag = true;
								for ( var i = 0; i < parameters.length; i++) {
									if (typeof parameters[i].eventname != "undefined") {
										if (typeof (parameters[i].triggerid) != "undefined") {
											$("#" + parameters[i].triggerid)
													.trigger(
															parameters[i].eventname);
										} else {
											$("#" + parameters[i].objid)
													.trigger(
															parameters[i].eventname);
										}
									}
								}
								$.livali.exeValidateNoEvent();
								if ($.livali.resultflag) {
									return true;
								} else {
									$.livali.resultflag = true;
									return false;
								}
							});
		}
	},

	validateHandler : function(event) {
		// 判断对象不显示时是否还需要验证
		if (!event.data.valinotvisible) {// 不显示时不用验证
			if (!$("#" + event.data.id).is(":visible")) {// 验证对象没显示,直接返回true
				return true;
			}
		}
		// 判断是否是忽略的对象
		if (!$.livali.isObjIgnore(event.data.id)) {
			// 先判断是否忽略该验证
			if (!$.livali.isIgnore(event.data.id, event.data.funcname)) {
				var jqueryObj = $(event.data.obj);
				// imageShow(jqueryObj);
				var result = true;
				// 因为调用验证方法后，可能动态改变
				// var msg = event.data.msg;
				var tp = event.data.tposition;
				var dp = event.data.detailposition;
				/**
				 * event.result为上一个事件处理函数的返回值
				 */
				if (typeof (event.result) == "undefined") {// 说明是第一个处理函数
					// 看验证函数是否有参数，如果有则传相应参数和event,没有则只传event
					if (typeof (event.data.fparameter) != "undefined") {
						var arr = new Array();
						for ( var i = 0; i < event.data.fparameter.length; i++) {
							var pm = null;
							// 判断参数类型是不是 function,如果是则执行该函数取得其返回值
							if (typeof (event.data.fparameter[i]) == "function") {
								pm = event.data.fparameter[i]();
							} else {
								pm = event.data.fparameter[i];
							}
							arr.push(pm);
						}
						arr.push(event);

						result = event.data.funcbody.apply(jqueryObj, arr);
					} else {

						result = event.data.funcbody
								.apply(jqueryObj, [ event ]);
					}

					if (!result) {
						$.livali.resultflag = false;
						messageShow(jqueryObj, event.data.msg, tp, dp);
						return false;
					}
					messageHide(jqueryObj);
					return true;
				} else {
					// 非第一个处理函数，要看上一个函数的处理结果是否为true,如果为false，说明上一个验证没通过，后面的就不用了
					if (event.result) {
						if (typeof (event.data.fparameter) != "undefined") {
							var arr = new Array();
							for ( var i = 0; i < event.data.fparameter.length; i++) {
								var pm = null;
								if (typeof (event.data.fparameter[i]) == "function") {
									pm = event.data.fparameter[i]();
								} else {
									pm = event.data.fparameter[i];
								}
								arr.push(pm);
							}
							arr.push(event);

							result = event.data.funcbody.apply(jqueryObj, arr);
						} else {

							result = event.data.funcbody.apply(jqueryObj,
									[ event ]);
						}
						if (!result) {
							$.livali.resultflag = false;
							messageShow(jqueryObj, event.data.msg, tp, dp);
							return false;
						}
						messageHide(jqueryObj);
						return true;
					}
					return false;
				}
			} else {// 是被忽略的方法
				return true;
			}
		} else {// 是忽略的对象
			return true;
		}

	},
	/**
	 * 对于一个对象的一个事件，验证通过后要执行的函数
	 * 
	 * @param event
	 */
	afterValidteHandler : function(event) {
		// 先判断是否忽略该验证
		if (!$.livali.isObjIgnore(event.data.id)) {
			if (!$.livali.isIgnore(event.data.id, event.data.funcname)) {
				if (event.result) {
				
					if (typeof (event.data.fparameter) != "undefined") {
						var arr = new Array();
						for ( var i = 0; i < event.data.fparameter.length; i++) {
							var pm = null;
							if (typeof (event.data.fparameter[i]) == "function") {
								pm = event.data.fparameter[i]();
							} else {
								pm = event.data.fparameter[i];
							}
							arr.push(pm);
						}
						 event.data.aftervalidate.apply(event.data.obj, arr);
					} else {
						 event.data.aftervalidate.apply(event.data.obj);
					}
				}
			}
		}

	},
	/**
	 * 
	 * 
	 */
	validateWithoutEventHandler : function(event) {

		var jqueryObj = $(event.data.obj);
		//imageShow(jqueryObj);
		var tp = event.data.tposition;
		var dp = event.data.detailposition;
		var result = event.data.funcbody.apply(jqueryObj, [ event ]);
		if (!result) {
			$.livali.resultflag = false;
			imageHide(jqueryObj);
			messageShow(jqueryObj, event.data.msg, tp, dp);
			return false;
		}
		imageHide(jqueryObj);
		/**
		 * 
		 * 
		 * 2013-03-13 什么时候应该执行关闭提示 还没理清
		 */
		// messageHide(jqueryObj);
		return true;
	},
	/**
	 * 触发所有验证
	 * 
	 * @returns {Boolean}
	 */
	validateAll : function() {
		$.livali.resultflag = true;
		// alert(param);
		for ( var i = 0; i < $.livali.param.length; i++) {
			if (typeof $.livali.param[i].eventname != "undefined") {
				if (typeof ($.livali.param[i].triggerid) != "undefined") {
					$("#" + $.livali.param[i].triggerid).trigger(
							$.livali.param[i].eventname);
				} else {
					$("#" + $.livali.param[i].objid).trigger(
							$.livali.param[i].eventname);
				}
			}
		}

		$.livali.exeValidateNoEvent();
		if ($.livali.resultflag) {
			return true;
		} else {
			$.livali.resultflag = true;
			return false;
		}
	},
	/**
	 * 2013-03-13 目前是将所有没有事件的函数 顺序执行 当有不通过的函数时即结束验证
	 * 这种方式没有针对各验证对象进行整理，对于同一对象同时绑定了事件的情况也没有很好的处理
	 */
	exeValidateNoEvent : function() {
		for ( var i = 0; i < $.livali.validateWithoutEvent.length; i++) {
			var obj = $("#" + $.livali.validateWithoutEvent[i].objid);
			// 先判断是否忽略该验证
			if (!$.livali.isIgnore($.livali.validateWithoutEvent[i].objid,
					$.livali.validateWithoutEvent[i].funcname)) {
				alert(obj.parent().children(".SD-tipbox").length);
				// 如果已经显示了提示，说明该对象上已有出错的验证，则该次忽略
				if (obj.parent().children(".SD-tipbox").length == 0) {
					data = $.livali.validateWithoutEvent[i];

					var event = {
						data : data
					};
					// 有一个验证没有通过时，即结束
					if (!$.livali.validateWithoutEventHandler(event)) {
						break;
					}
				} else {
					break;
				}
			}
		}
	},
	/**
	 * 每个验证对象，同一事件绑定的最后一个函数， 当执行到该函数时，说明前面的所有验证都已经结束，不论是否通过，都应该关闭等待图片
	 * 
	 * @param event
	 */
	//closeImg : function(event) {
	//	var jqueryObj = $(event.data);
	//	imageHide(jqueryObj);
		
	//},
	//openImg : function(event) {
	//	var jqueryObj = $(event.data);
	//	imageShow(jqueryObj);
		// setTimeout("return true",1000);

	//},
	/**
	 * 增加忽略的验证
	 * 
	 * @param object
	 * @param funcName
	 */
	addIgnore : function(objectId, funcName) {
		var ign = {
			objId : objectId,
			fcname : funcName
		};
		$.livali.ignoreValidates.push(ign);

	},
	/**
	 * 删除忽略
	 * 
	 * @param objectId
	 * @param funcName
	 */
	deleteIgnore : function(objectId, funcName) {

		for ( var i = 0; i < $.livali.ignoreValidates.length; i++) {
			if ($.livali.ignoreValidates[i].objId == objectId
					&& $.livali.ignoreValidates[i].fcname == funcName) {
				$.livali.ignoreValidates.splice(i, 1);
			}
		}
	},
	/**
	 * 判断某对象的验证方法是否忽略，忽略时返回true
	 * 
	 * @param objectId
	 * @param funcName
	 */
	isIgnore : function(objectId, funcName) {
		for ( var i = 0; i < $.livali.ignoreValidates.length; i++) {
			if ($.livali.ignoreValidates[i].objId == objectId
					&& $.livali.ignoreValidates[i].fcname == funcName) {
				return true;
			}
		}
		return false;
	},
	/**
	 * 增加忽略的对象
	 * 
	 * @param odjectId
	 */
	addObjIgnore : function(objectId) {
		if (!$.livali.isObjIgnore(objectId)) {
			$.livali.ignoreObjValidates.push(objectId);
		}
	},
	/**
	 * 删除忽略的对象
	 * 
	 * @param objectId
	 */
	deleteObjIgnore : function(objectId) {
		for ( var i = 0; i < $.livali.ignoreObjValidates.length; i++) {
			if ($.livali.ignoreObjValidates[i] == objectId) {
				$.livali.ignoreObjValidates.splice(i, 1);
			}
		}
	},
	/**
	 * 判断某对象是否忽略
	 * 
	 * @param objectId
	 * @returns {Boolean}
	 */
	isObjIgnore : function(objectId) {
		for ( var i = 0; i < $.livali.ignoreObjValidates.length; i++) {
			if ($.livali.ignoreObjValidates[i] == objectId) {
				return true;
			}
		}
		return false;
	},
	/**
	 * 非空验证
	 * 
	 * @param event
	 * @returns {Boolean}
	 */
	notNull : function(event) {
		var jqueryObj = $(event.data.obj);

		if ( !jqueryObj.attr("DISABLED") ) {
			if (trim(jqueryObj.val()) == "") {

				if (event.data.msg == "") {
					event.data.msg = $.validateLanguage.notNullMsg;
				}
				return false;
			}
		}

		return true;
	},
	/**
	 * 长度验证
	 * 
	 * @param event
	 */
	lengthLimit : function(limitValue, event) {
		var jqueryObj = $(event.data.obj);
		//var length = getLength(trim(jqueryObj.val()));
		var length = trim(jqueryObj.val()).length;
		if (length > limitValue) {
			if (event.data.msg == "") {
				event.data.msg = $.validateLanguage.lengthLimitMsg;
			}
			event.data.msg = event.data.msg.replace("#@#", limitValue);
			return false;
		}
		return true;
	},
	/**
	 * 数字验证(正整数)
	 * 
	 * @param event
	 */
	isPInteger : function(event) {
		var jqueryObj = $(event.data.obj);
		if (!$.livali.regTest($.livali.pIntegerReg, trim(jqueryObj.val()))) {
			if (event.data.msg == "") {
				event.data.msg = $.validateLanguage.isPIntegerMsg;
			}
			return false;
		}
		return true;
	},
	/**
	 * 数字验证(非负整数)
	 * 
	 * @param event
	 * @returns {Boolean}
	 */
	notNInteger : function(event) {
		var jqueryObj = $(event.data.obj);
		if (!$.livali.regTest($.livali.notNIntegerReg, trim(jqueryObj.val()))) {
			if (event.data.msg == "") {
				event.data.msg = $.validateLanguage.notNIntegerMsg;
			}
			return false;
		}
		return true;
	},
	/**
	 * IP验证
	 * 
	 * @param event
	 * @returns {Boolean}
	 */
	isIpv4 : function(event) {
		var jqueryObj = $(event.data.obj);
		if (!$.livali.regTest($.livali.isIpv4Reg, trim(jqueryObj.val()))) {
			if (event.data.msg == "") {
				event.data.msg = $.validateLanguage.isIpv4Msg;
			}
			return false;
		}
		return true;
	},
	/**
	 * 日期时间格式判定
	 * 
	 * @param event
	 * @returns {Boolean}
	 */
	isDateTime : function(event) {
		var jqueryObj = $(event.data.obj);
		if (!$.livali.regTest($.livali.isDateTimeReg, trim(jqueryObj.val()))) {
			if (event.data.msg == "") {
				event.data.msg = $.validateLanguage.isDateTimeMsg;
			}
			return false;
		}
		return true;
	},
	/**
	 * 日期格式判定
	 * 
	 * @param event
	 * @returns {Boolean}
	 */
	isDate : function(event) {
		var jqueryObj = $(event.data.obj);
		if (!$.livali.regTest($.livali.isDateReg, trim(jqueryObj.val()))) {
			if (event.data.msg == "") {
				event.data.msg = $.validateLanguage.isDateMsg;
			}
			return false;
		}
		return true;
	},
	/**
	 * 判断是否有特殊字符 &%()<>\'",
	 * 
	 * 2013-10-28 使用正则表达试验证时，第二次会通过验证，原因不明
	 * 现改为非正则表达式方式实现
	 */
	noSpecialCharacter : function(event) {
		var jqueryObj = $(event.data.obj);
	/*	if ($.livali.regTest($.livali.specialCharacterReg, trim(jqueryObj.val()))) {
			if (event.data.msg == "") {
				event.data.msg = $.validateLanguage.noSpecialCharacterMsg;
			}
			return false;
		}*/
		var SPC = "&%()<>\\'\"";
		var val = trim(jqueryObj.val());
		for(var i=0;i<val.length;i++){
			if(SPC.indexOf(val.charAt(i))!= -1){
				if (event.data.msg == "") {
					event.data.msg = $.validateLanguage.noSpecialCharacterMsg;
				}
				return false;
			}
		}
		return true;
	},
	/**
	 * 多选列表非空判定
	 */
	multiSelNotNull : function(event) {
		var jqueryObj = $(event.data.obj);
		var optionNum = jqueryObj.find("option").size();
		if (optionNum <= 0) {
			event.data.msg = $.validateLanguage.notNullMsg;
			return false;
		}
		return true;
	},
	/**
	 * checkboxlist至少勾选了指定数目校验
	 * 
	 * @param chkName
	 *            checkboxlist(复选框组)名称
	 * @param leastChkNum
	 *            至少勾选数目
	 */
	leastChkNum : function(chkName, leastChkNum, event) {
		var jqueryObj = $("input[type='checkbox'][name='" + chkName
				+ "']:checked");

		if (jqueryObj.size() < leastChkNum) {
			if (event.data.msg == "") {
				event.data.msg = $.validateLanguage.leastChkNumMsg;
			}
			event.data.msg = event.data.msg.replace("#@#", leastChkNum);
			return false;
		}
		return true;
	},
	/**
	 * 数字验证(范围整数)
	 * 
	 * @param min
	 *            值为null表示支持无穷小
	 * @param max
	 *            值为null表示支持无穷大
	 * 该方法无法随意配置提示信息
	 */
	rangeInteger : function(min, max, event) {
		var jqueryObj = $(event.data.obj);
		if ( !jqueryObj.attr("DISABLED") ) {
			var result = true;
			var val = jqueryObj.val();
			var dispmin = "";
			var dispmax = "";
			if (min == null) {
				dispmin = "-∞";
			} else {
				dispmin = min + "";
			}
			if (max == null) {
				dispmax = "+∞";
			} else {
				dispmax = max + "";
			}
			if ($.livali.regTest($.livali.integerReg, val)) {
				val = parseInt(val);
				if (min != null && val < min) {
					result = false;
				}
				if (max != null && val > max ) {
					result = false;
				}
			} else {
				result = false;
			}
			if (!result) {
				//if (event.data.msg == "") {
					//event.data.msg = $.validateLanguage.rangeIntegerMsg;
				//}
				event.data.msg = $.validateLanguage.rangeIntegerMsg.replace("#@#", "[" + dispmin + ","
						+ dispmax + "]");
				return false;
			}
		}
		return true;
	},

	/**
	 * 最小时间验证
	 * @param minDateTime
	 * @param event
	 * @returns {Boolean}
	 */
	futureDateTime : function(minDateTime,event) {
		var jqueryObj = $(event.data.obj);
		var datetime = trim(jqueryObj.val());
		var mdt = $.livali.parseDateTime(minDateTime);
		var dt = $.livali.parseDateTime(datetime);
		if(datetime == "")
			return true;
		if(dt<mdt){
			if (event.data.msg == "") {
				event.data.msg = $.validateLanguage.futureDateTimeMsg;
			}
			event.data.msg = event.data.msg.replace("#@#", minDateTime);
			return false;
		}
		return true;
	},
	/**
	 * 最小日期验证
	 * @param minDate
	 * @param event
	 * @returns {Boolean}
	 */
	futureDate : function(minDate,event) {
		var jqueryObj = $(event.data.obj);
		var date = trim(jqueryObj.val());
		var md = $.livali.parseDate(minDate);
		var d = $.livali.parseDate(date);
		if(date == "")
			return true;
		if(d<md){
			if (event.data.msg == "") {
				event.data.msg = $.validateLanguage.futureDateMsg;
			}
			event.data.msg = event.data.msg.replace("#@#", minDate);
			return false;
		}
		return true;
	},
	/**
	 * 最大时间验证
	 * @param minDateTime
	 * @param event
	 * @returns {Boolean}
	 */
	pastDateTime : function(maxDateTime,event) {
		var jqueryObj = $(event.data.obj);
		var datetime = trim(jqueryObj.val());
		var mdt = $.livali.parseDateTime(maxDateTime);
		var dt = $.livali.parseDateTime(datetime);
		if(datetime == "")
			return true;
		if(dt>mdt){
			if (event.data.msg == "") {
				event.data.msg = $.validateLanguage.pastDateTimeMsg;
			}
			event.data.msg = event.data.msg.replace("#@#", minDateTime);
			return false;
		}
		return true;
	},
	/**
	 * 最大日期验证
	 * @param minDate
	 * @param event
	 * @returns {Boolean}
	 */
	pastDate : function(maxDate,event) {
		var jqueryObj = $(event.data.obj);
		var date = trim(jqueryObj.val());
		var md = $.livali.parseDate(minDate);
		var d = $.livali.parseDate(date);
		if(date == "")
			return true;
		if(d>md){
			if (event.data.msg == "") {
				event.data.msg = $.validateLanguage.pastDateMsg;
			}
			event.data.msg = event.data.msg.replace("#@#", minDate);
			return false;
		}
		return true;
	},
	/**
	 * 正则表达式判定 符合：True 否则：False
	 * 
	 * @param regular
	 * @param str
	 */
	regTest : function(regular, str) {

		if (regular.test(str)) {
			return true;
		}
		return false;
	},
	/**
	 * 转换字符型日期为date类型 yyyy-mm-dd yyyy/mm/dd
	 * 
	 * @param d
	 * @returns {Date}
	 */
	parseDate : function(d) {

		var dateParts = d.split("-");
		if (dateParts == d)
			dateParts = d.split("/");

		return new Date(dateParts[0], (dateParts[1] - 1), dateParts[2]);
	},
	/**
	 * 转换字符型时间为date类型 yyyy-mm-dd hh:MM:ss yyyy/mm/dd hh:MM:ss
	 * 
	 * @param dt
	 * @returns {Date}
	 */
	parseDateTime : function(dt) {

		dt = dt.replace(/\s+/g, " ");
		var dtParts = dt.split(" ");

		var d = dtParts[0];
		var t = dtParts[1];
		var dParts = d.split("-");
		if (dParts == d) {
			dParts = d.split("/");
		}
		var tParts = t.split(":");
		return new Date(dParts[0], (dParts[1] - 1), dParts[2], tParts[0],
				tParts[1], tParts[2]);

	},
	/**
	 * 只能输入字母数字下划线
	 * @param event
	 * @returns {Boolean}
	 */
    numLetterUnderLineOnly :function(event){
    	var jqueryObj = $(event.data.obj);
		if (!$.livali.regTest($.livali.numLetterUnderLineOnlyReg, trim(jqueryObj.val()))) {
			if (event.data.msg == "") {
				event.data.msg = $.validateLanguage.numLetterUnderLineOnlyMsg;
			}
			return false;
		}
		return true;
    }
};